home *** CD-ROM | disk | FTP | other *** search
/ Apple WWDC 1996 / WWDC96_1996 (CD).toast / Technology Materials / MacOS 8 Resources / Developer Tools / Mac OS 8 Interfaces & Libraries / Interfaces / PInterfaces / Quickdraw.p < prev    next >
Encoding:
Text File  |  1996-05-01  |  51.1 KB  |  1,833 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Quickdraw.p
  3.  
  4.      Contains:    Quickdraw Graphics Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.0d3 on Copland DR1
  8.  
  9.      Copyright:    © 1984-1996 by Apple Computer, Inc.  All rights reserved.
  10.  
  11.      Bugs?:        If you find a problem with this file, send the file and version
  12.                  information (from above) and the problem description to:
  13.  
  14.                      Internet:    apple.bugs@applelink.apple.com
  15.                      AppleLink:    APPLE.BUGS
  16.  
  17. }
  18. {$IFC UNDEFINED UsingIncludes}
  19. {$SETC UsingIncludes := 0}
  20. {$ENDC}
  21.  
  22. {$IFC NOT UsingIncludes}
  23.  UNIT Quickdraw;
  24.  INTERFACE
  25. {$ENDC}
  26.  
  27. {$IFC UNDEFINED __QUICKDRAW__}
  28. {$SETC __QUICKDRAW__ := 1}
  29.  
  30. {$I+}
  31. {$SETC QuickdrawIncludes := UsingIncludes}
  32. {$SETC UsingIncludes := 1}
  33.  
  34. {$IFC UNDEFINED __TYPES__}
  35. {$I Types.p}
  36. {$ENDC}
  37. {$IFC UNDEFINED __MIXEDMODE__}
  38. {$I MixedMode.p}
  39. {$ENDC}
  40. {$IFC UNDEFINED __QUICKDRAWTEXT__}
  41. {$I QuickdrawText.p}
  42. {$ENDC}
  43.  
  44. {$PUSH}
  45. {$ALIGN MAC68K}
  46. {$LibExport+}
  47.  
  48.  
  49. TYPE
  50.     RGBColorPtr = ^RGBColor;
  51.     RGBColor = RECORD
  52.         red:                    INTEGER;                                { magnitude of red component }
  53.         green:                    INTEGER;                                { magnitude of green component }
  54.         blue:                    INTEGER;                                { magnitude of blue component }
  55.     END;
  56.  
  57.     RGBColorHdl                            = ^RGBColorPtr;
  58.     ColorSpecPtr = ^ColorSpec;
  59.     ColorSpec = RECORD
  60.         value:                    INTEGER;                                { index or other value }
  61.         rgb:                    RGBColor;                                { true color }
  62.     END;
  63.  
  64.     CSpecArray                            = ARRAY [0..0] OF ColorSpec;
  65.     ColorTablePtr = ^ColorTable;
  66.     ColorTable = RECORD
  67.         ctSeed:                    LONGINT;                                { unique identifier for table }
  68.         ctFlags:                INTEGER;                                { high bit: 0 = PixMap; 1 = device }
  69.         ctSize:                    INTEGER;                                { number of entries in CTTable }
  70.         ctTable:                CSpecArray;                                { array [0..0] of ColorSpec }
  71.     END;
  72.  
  73.     CTabPtr                                = ^ColorTable;
  74.     CTabHandle                            = ^CTabPtr;
  75.     xColorSpecPtr = ^xColorSpec;
  76.     xColorSpec = RECORD
  77.         value:                    INTEGER;                                { index or other value }
  78.         rgb:                    RGBColor;                                { true color }
  79.         xalpha:                    INTEGER;
  80.     END;
  81.  
  82.     xCSpecArray                            = ARRAY [0..0] OF xColorSpec;
  83.     GammaTblPtr = ^GammaTbl;
  84.     GammaTbl = RECORD
  85.         gVersion:                INTEGER;                                { gamma version number }
  86.         gType:                    INTEGER;                                { gamma data type }
  87.         gFormulaSize:            INTEGER;                                { Formula data size }
  88.         gChanCnt:                INTEGER;                                { number of channels of data }
  89.         gDataCnt:                INTEGER;                                { number of values/channel }
  90.         gDataWidth:                INTEGER;                                { bits/corrected value (data packed to next larger byte size) }
  91.         gFormulaData:            ARRAY [0..0] OF INTEGER;                { data for formulas followed by gamma values }
  92.     END;
  93.  
  94.     GammaTblHandle                        = ^GammaTblPtr;
  95.     Bits16                                = ARRAY [0..15] OF INTEGER;
  96.     CursorPtr = ^Cursor;
  97.     Cursor = RECORD
  98.         data:                    Bits16;
  99.         mask:                    Bits16;
  100.         hotSpot:                Point;
  101.     END;
  102.  
  103.     CursPtr                                = ^Cursor;
  104.     CursHandle                            = ^CursPtr;
  105. {$IFC FOR_SYSTEM7_AND_SYSTEM8_COOPERATIVE }
  106.  
  107. CONST
  108.     invalColReq                    = -1;                            { invalid color table request }
  109.                                                                 {  transfer modes  }
  110.     srcCopy                        = 0;                            { the 16 transfer modes }
  111.     srcOr                        = 1;
  112.     srcXor                        = 2;
  113.     srcBic                        = 3;
  114.     notSrcCopy                    = 4;
  115.     notSrcOr                    = 5;
  116.     notSrcXor                    = 6;
  117.     notSrcBic                    = 7;
  118.     patCopy                        = 8;
  119.     patOr                        = 9;
  120.     patXor                        = 10;
  121.     patBic                        = 11;
  122.     notPatCopy                    = 12;
  123.     notPatOr                    = 13;
  124.     notPatXor                    = 14;
  125.     notPatBic                    = 15;                            {  Special Text Transfer Mode  }
  126.     grayishTextOr                = 49;
  127.     hilitetransfermode            = 50;
  128.     hilite                        = 50;                            {  Arithmetic transfer modes  }
  129.     blend                        = 32;
  130.     addPin                        = 33;
  131.  
  132.     addOver                        = 34;
  133.     subPin                        = 35;
  134.     addMax                        = 37;
  135.     adMax                        = 37;
  136.     subOver                        = 38;
  137.     adMin                        = 39;
  138.     ditherCopy                    = 64;                            {  Transparent mode constant  }
  139.     transparent                    = 36;
  140.     italicBit                    = 1;
  141.     ulineBit                    = 2;
  142.     outlineBit                    = 3;
  143.     shadowBit                    = 4;
  144.     condenseBit                    = 5;
  145.     extendBit                    = 6;                            {  QuickDraw color separation constants  }
  146.     normalBit                    = 0;                            { normal screen mapping }
  147.     inverseBit                    = 1;                            { inverse screen mapping }
  148.     redBit                        = 4;                            { RGB additive mapping }
  149.     greenBit                    = 3;
  150.     blueBit                        = 2;
  151.     cyanBit                        = 8;                            { CMYBk subtractive mapping }
  152.     magentaBit                    = 7;
  153.     yellowBit                    = 6;
  154.     blackBit                    = 5;
  155.     blackColor                    = 33;                            { colors expressed in these mappings }
  156.     whiteColor                    = 30;
  157.     redColor                    = 205;
  158.  
  159.     greenColor                    = 341;
  160.     blueColor                    = 409;
  161.     cyanColor                    = 273;
  162.     magentaColor                = 137;
  163.     yellowColor                    = 69;
  164.     picLParen                    = 0;                            { standard picture comments }
  165.     picRParen                    = 1;
  166.     clutType                    = 0;                            { 0 if lookup table }
  167.     fixedType                    = 1;                            { 1 if fixed table }
  168.     directType                    = 2;                            { 2 if direct values }
  169.     gdDevType                    = 0;                            { 0 = monochrome 1 = color }
  170.  
  171.     interlacedDevice            = 2;                            {  1 if single pixel lines look bad  }
  172.     roundedDevice                = 5;                            {  1 if device has been “rounded” into the GrayRgn  }
  173.     hasAuxMenuBar                = 6;                            {  1 if device has an aux menu bar on it  }
  174.     burstDevice                    = 7;
  175.     ext32Device                    = 8;
  176.     ramInit                        = 10;                            { 1 if initialized from 'scrn' resource }
  177.     mainScreen                    = 11;                            {  1 if main screen  }
  178.     allInit                        = 12;                            {  1 if all devices initialized  }
  179.     screenDevice                = 13;                            { 1 if screen device [not used] }
  180.     noDriver                    = 14;                            {  1 if no driver for this GDevice  }
  181.     screenActive                = 15;                            { 1 if in use }
  182.     hiliteBit                    = 7;                            { flag bit in HiliteMode (lowMem flag) }
  183.     pHiliteBit                    = 0;                            { flag bit in HiliteMode used with BitClr procedure }
  184.     defQDColors                    = 127;                            { resource ID of clut for default QDColors }
  185.                                                                 {  pixel type  }
  186.     RGBDirect                    = 16;                            {  16 & 32 bits/pixel pixelType value  }
  187.                                                                 {  pmVersion values  }
  188.     baseAddr32                    = 4;                            { pixmap base address is 32-bit address }
  189.  
  190.     sysPatListID                = 0;
  191.     iBeamCursor                    = 1;
  192.     crossCursor                    = 2;
  193.     plusCursor                    = 3;
  194.     watchCursor                    = 4;
  195.  
  196.     kQDGrafVerbFrame            = 0;
  197.     kQDGrafVerbPaint            = 1;
  198.     kQDGrafVerbErase            = 2;
  199.     kQDGrafVerbInvert            = 3;
  200.     kQDGrafVerbFill                = 4;
  201.  
  202. {$IFC OLDROUTINENAMES }
  203.     frame                        = 0;
  204.     paint                        = 1;
  205.     erase                        = 2;
  206.     invert                        = 3;
  207.     fill                        = 4;
  208.  
  209. {$ENDC}
  210.  
  211. TYPE
  212.     GrafVerb                            = SInt8;
  213.  
  214. CONST
  215.     chunky                        = 0;
  216.     chunkyPlanar                = 1;
  217.     planar                        = 2;
  218.  
  219.  
  220. TYPE
  221.     PixelType                            = SInt8;
  222. {
  223. **************   IMPORTANT NOTE REGARDING Pattern  **************************************
  224.    Patterns were originally defined as:
  225.    
  226.         C:             typedef unsigned char Pattern[8];
  227.         Pascal:        Pattern = PACKED ARRAY [0..7] OF 0..255;
  228.         
  229.    The old array defintion of Pattern would cause 68000 based CPU's to crash in certain circum-
  230.    stances. The new struct definition is safe, but may require source code changes to compile.
  231.    Read the details in TechNote "Platforms & Tools" #PT 38.
  232.     
  233. ********************************************************************************************
  234. }
  235.     PatternPtr = ^Pattern;
  236.     Pattern = RECORD
  237.         pat:                    PACKED ARRAY [0..7] OF UInt8;
  238.     END;
  239.  
  240. {
  241.  ConstPatternParam is now longer needed.  It was first created when Pattern was an array.
  242.  Now that Pattern is a struct, it is more straight forward just add the "const" qualifier
  243.  on the parameter type (e.g. "const Pattern * pat" instead of "ConstPatternParam pat").
  244. }
  245.     PatPtr                                = ^Pattern;
  246.     PatHandle                            = ^PatPtr;
  247.     QDByte                                = SignedByte;
  248.     QDPtr                                = Ptr;
  249.     QDHandle                            = Handle;
  250.     QDErr                                = INTEGER;
  251.  
  252. CONST
  253.     singleDevicesBit            = 0;
  254.     dontMatchSeedsBit            = 1;
  255.     allDevicesBit                = 2;
  256.  
  257.     singleDevices                = $01;
  258.     dontMatchSeeds                = $02;
  259.     allDevices                    = $04;
  260.  
  261.  
  262. TYPE
  263.     DeviceLoopFlags                        = LONGINT;
  264.     BitMapPtr = ^BitMap;
  265.     BitMap = RECORD
  266.         baseAddr:                Ptr;
  267.         rowBytes:                INTEGER;
  268.         bounds:                    Rect;
  269.     END;
  270.  
  271.     BitMapHandle                        = ^BitMapPtr;
  272.     PenStatePtr = ^PenState;
  273.     PenState = RECORD
  274.         pnLoc:                    Point;
  275.         pnSize:                    Point;
  276.         pnMode:                    INTEGER;
  277.         pnPat:                    Pattern;
  278.     END;
  279.  
  280.     RegionPtr = ^Region;
  281.     Region = RECORD
  282.         rgnSize:                INTEGER;                                { size in bytes }
  283.         rgnBBox:                Rect;                                    { enclosing rectangle }
  284.     END;
  285.  
  286.     RgnPtr                                = ^Region;
  287.     RgnHandle                            = ^RgnPtr;
  288.     PicturePtr = ^Picture;
  289.     Picture = RECORD
  290.         picSize:                INTEGER;
  291.         picFrame:                Rect;
  292.     END;
  293.  
  294.     PicPtr                                = ^Picture;
  295.     PicHandle                            = ^PicPtr;
  296.     PolygonPtr = ^Polygon;
  297.     Polygon = RECORD
  298.         polySize:                INTEGER;
  299.         polyBBox:                Rect;
  300.         polyPoints:                ARRAY [0..0] OF Point;
  301.     END;
  302.  
  303.     PolyPtr                                = ^Polygon;
  304.     PolyHandle                            = ^PolyPtr;
  305.     QDTextProcPtr = ProcPtr;  { PROCEDURE QDText(byteCount: INTEGER; textBuf: Ptr; numer: Point; denom: Point); }
  306.  
  307.     QDLineProcPtr = ProcPtr;  { PROCEDURE QDLine(newPt: Point); }
  308.  
  309.     QDRectProcPtr = ProcPtr;  { PROCEDURE QDRect(verb: GrafVerb; VAR r: Rect); }
  310.  
  311.     QDRRectProcPtr = ProcPtr;  { PROCEDURE QDRRect(verb: GrafVerb; VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER); }
  312.  
  313.     QDOvalProcPtr = ProcPtr;  { PROCEDURE QDOval(verb: GrafVerb; VAR r: Rect); }
  314.  
  315.     QDArcProcPtr = ProcPtr;  { PROCEDURE QDArc(verb: GrafVerb; VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER); }
  316.  
  317.     QDPolyProcPtr = ProcPtr;  { PROCEDURE QDPoly(verb: GrafVerb; poly: PolyHandle); }
  318.  
  319.     QDRgnProcPtr = ProcPtr;  { PROCEDURE QDRgn(verb: GrafVerb; rgn: RgnHandle); }
  320.  
  321.     QDBitsProcPtr = ProcPtr;  { PROCEDURE QDBits(VAR srcBits: BitMap; VAR srcRect: Rect; VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle); }
  322.  
  323.     QDCommentProcPtr = ProcPtr;  { PROCEDURE QDComment(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle); }
  324.  
  325.     QDTxMeasProcPtr = ProcPtr;  { FUNCTION QDTxMeas(byteCount: INTEGER; textAddr: Ptr; VAR numer: Point; VAR denom: Point; VAR info: FontInfo): INTEGER; }
  326.  
  327.     QDGetPicProcPtr = ProcPtr;  { PROCEDURE QDGetPic(dataPtr: Ptr; byteCount: INTEGER); }
  328.  
  329.     QDPutPicProcPtr = ProcPtr;  { PROCEDURE QDPutPic(dataPtr: Ptr; byteCount: INTEGER); }
  330.  
  331.     QDOpcodeProcPtr = ProcPtr;  { PROCEDURE QDOpcode(VAR fromRect: Rect; VAR toRect: Rect; opcode: INTEGER; version: INTEGER); }
  332.  
  333.     QDJShieldCursorProcPtr = ProcPtr;  { PROCEDURE QDJShieldCursor(left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER); }
  334.  
  335.     QDTextUPP = UniversalProcPtr;
  336.     QDLineUPP = UniversalProcPtr;
  337.     QDRectUPP = UniversalProcPtr;
  338.     QDRRectUPP = UniversalProcPtr;
  339.     QDOvalUPP = UniversalProcPtr;
  340.     QDArcUPP = UniversalProcPtr;
  341.     QDPolyUPP = UniversalProcPtr;
  342.     QDRgnUPP = UniversalProcPtr;
  343.     QDBitsUPP = UniversalProcPtr;
  344.     QDCommentUPP = UniversalProcPtr;
  345.     QDTxMeasUPP = UniversalProcPtr;
  346.     QDGetPicUPP = UniversalProcPtr;
  347.     QDPutPicUPP = UniversalProcPtr;
  348.     QDOpcodeUPP = UniversalProcPtr;
  349.     QDJShieldCursorUPP = UniversalProcPtr;
  350.     QDProcsPtr = ^QDProcs;
  351.     QDProcs = RECORD
  352.         textProc:                QDTextUPP;
  353.         lineProc:                QDLineUPP;
  354.         rectProc:                QDRectUPP;
  355.         rRectProc:                QDRRectUPP;
  356.         ovalProc:                QDOvalUPP;
  357.         arcProc:                QDArcUPP;
  358.         polyProc:                QDPolyUPP;
  359.         rgnProc:                QDRgnUPP;
  360.         bitsProc:                QDBitsUPP;
  361.         commentProc:            QDCommentUPP;
  362.         txMeasProc:                QDTxMeasUPP;
  363.         getPicProc:                QDGetPicUPP;
  364.         putPicProc:                QDPutPicUPP;
  365.     END;
  366.  
  367.  
  368. CONST
  369.     uppQDTextProcInfo = $00003F80;
  370.     uppQDLineProcInfo = $000000C0;
  371.     uppQDRectProcInfo = $00000340;
  372.     uppQDRRectProcInfo = $00002B40;
  373.     uppQDOvalProcInfo = $00000340;
  374.     uppQDArcProcInfo = $00002B40;
  375.     uppQDPolyProcInfo = $00000340;
  376.     uppQDRgnProcInfo = $00000340;
  377.     uppQDBitsProcInfo = $0000EFC0;
  378.     uppQDCommentProcInfo = $00000E80;
  379.     uppQDTxMeasProcInfo = $0000FFA0;
  380.     uppQDGetPicProcInfo = $000002C0;
  381.     uppQDPutPicProcInfo = $000002C0;
  382.     uppQDOpcodeProcInfo = $00002BC0;
  383.     uppQDJShieldCursorProcInfo = $00002A80;
  384.  
  385. FUNCTION NewQDTextProc(userRoutine: QDTextProcPtr): QDTextUPP;
  386.     {$IFC NOT GENERATINGCFM }
  387.     INLINE $2E9F;
  388.     {$ENDC}
  389.  
  390. FUNCTION NewQDLineProc(userRoutine: QDLineProcPtr): QDLineUPP;
  391.     {$IFC NOT GENERATINGCFM }
  392.     INLINE $2E9F;
  393.     {$ENDC}
  394.  
  395. FUNCTION NewQDRectProc(userRoutine: QDRectProcPtr): QDRectUPP;
  396.     {$IFC NOT GENERATINGCFM }
  397.     INLINE $2E9F;
  398.     {$ENDC}
  399.  
  400. FUNCTION NewQDRRectProc(userRoutine: QDRRectProcPtr): QDRRectUPP;
  401.     {$IFC NOT GENERATINGCFM }
  402.     INLINE $2E9F;
  403.     {$ENDC}
  404.  
  405. FUNCTION NewQDOvalProc(userRoutine: QDOvalProcPtr): QDOvalUPP;
  406.     {$IFC NOT GENERATINGCFM }
  407.     INLINE $2E9F;
  408.     {$ENDC}
  409.  
  410. FUNCTION NewQDArcProc(userRoutine: QDArcProcPtr): QDArcUPP;
  411.     {$IFC NOT GENERATINGCFM }
  412.     INLINE $2E9F;
  413.     {$ENDC}
  414.  
  415. FUNCTION NewQDPolyProc(userRoutine: QDPolyProcPtr): QDPolyUPP;
  416.     {$IFC NOT GENERATINGCFM }
  417.     INLINE $2E9F;
  418.     {$ENDC}
  419.  
  420. FUNCTION NewQDRgnProc(userRoutine: QDRgnProcPtr): QDRgnUPP;
  421.     {$IFC NOT GENERATINGCFM }
  422.     INLINE $2E9F;
  423.     {$ENDC}
  424.  
  425. FUNCTION NewQDBitsProc(userRoutine: QDBitsProcPtr): QDBitsUPP;
  426.     {$IFC NOT GENERATINGCFM }
  427.     INLINE $2E9F;
  428.     {$ENDC}
  429.  
  430. FUNCTION NewQDCommentProc(userRoutine: QDCommentProcPtr): QDCommentUPP;
  431.     {$IFC NOT GENERATINGCFM }
  432.     INLINE $2E9F;
  433.     {$ENDC}
  434.  
  435. FUNCTION NewQDTxMeasProc(userRoutine: QDTxMeasProcPtr): QDTxMeasUPP;
  436.     {$IFC NOT GENERATINGCFM }
  437.     INLINE $2E9F;
  438.     {$ENDC}
  439.  
  440. FUNCTION NewQDGetPicProc(userRoutine: QDGetPicProcPtr): QDGetPicUPP;
  441.     {$IFC NOT GENERATINGCFM }
  442.     INLINE $2E9F;
  443.     {$ENDC}
  444.  
  445. FUNCTION NewQDPutPicProc(userRoutine: QDPutPicProcPtr): QDPutPicUPP;
  446.     {$IFC NOT GENERATINGCFM }
  447.     INLINE $2E9F;
  448.     {$ENDC}
  449.  
  450. FUNCTION NewQDOpcodeProc(userRoutine: QDOpcodeProcPtr): QDOpcodeUPP;
  451.     {$IFC NOT GENERATINGCFM }
  452.     INLINE $2E9F;
  453.     {$ENDC}
  454.  
  455. FUNCTION NewQDJShieldCursorProc(userRoutine: QDJShieldCursorProcPtr): QDJShieldCursorUPP;
  456.     {$IFC NOT GENERATINGCFM }
  457.     INLINE $2E9F;
  458.     {$ENDC}
  459.  
  460. PROCEDURE CallQDTextProc(byteCount: INTEGER; textBuf: Ptr; numer: Point; denom: Point; userRoutine: QDTextUPP);
  461.     {$IFC NOT GENERATINGCFM}
  462.     INLINE $205F, $4E90;
  463.     {$ENDC}
  464.  
  465. PROCEDURE CallQDLineProc(newPt: Point; userRoutine: QDLineUPP);
  466.     {$IFC NOT GENERATINGCFM}
  467.     INLINE $205F, $4E90;
  468.     {$ENDC}
  469.  
  470. PROCEDURE CallQDRectProc(verb: GrafVerb; VAR r: Rect; userRoutine: QDRectUPP);
  471.     {$IFC NOT GENERATINGCFM}
  472.     INLINE $205F, $4E90;
  473.     {$ENDC}
  474.  
  475. PROCEDURE CallQDRRectProc(verb: GrafVerb; VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER; userRoutine: QDRRectUPP);
  476.     {$IFC NOT GENERATINGCFM}
  477.     INLINE $205F, $4E90;
  478.     {$ENDC}
  479.  
  480. PROCEDURE CallQDOvalProc(verb: GrafVerb; VAR r: Rect; userRoutine: QDOvalUPP);
  481.     {$IFC NOT GENERATINGCFM}
  482.     INLINE $205F, $4E90;
  483.     {$ENDC}
  484.  
  485. PROCEDURE CallQDArcProc(verb: GrafVerb; VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER; userRoutine: QDArcUPP);
  486.     {$IFC NOT GENERATINGCFM}
  487.     INLINE $205F, $4E90;
  488.     {$ENDC}
  489.  
  490. PROCEDURE CallQDPolyProc(verb: GrafVerb; poly: PolyHandle; userRoutine: QDPolyUPP);
  491.     {$IFC NOT GENERATINGCFM}
  492.     INLINE $205F, $4E90;
  493.     {$ENDC}
  494.  
  495. PROCEDURE CallQDRgnProc(verb: GrafVerb; rgn: RgnHandle; userRoutine: QDRgnUPP);
  496.     {$IFC NOT GENERATINGCFM}
  497.     INLINE $205F, $4E90;
  498.     {$ENDC}
  499.  
  500. PROCEDURE CallQDBitsProc(VAR srcBits: BitMap; VAR srcRect: Rect; VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle; userRoutine: QDBitsUPP);
  501.     {$IFC NOT GENERATINGCFM}
  502.     INLINE $205F, $4E90;
  503.     {$ENDC}
  504.  
  505. PROCEDURE CallQDCommentProc(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle; userRoutine: QDCommentUPP);
  506.     {$IFC NOT GENERATINGCFM}
  507.     INLINE $205F, $4E90;
  508.     {$ENDC}
  509.  
  510. FUNCTION CallQDTxMeasProc(byteCount: INTEGER; textAddr: Ptr; VAR numer: Point; VAR denom: Point; VAR info: FontInfo; userRoutine: QDTxMeasUPP): INTEGER;
  511.     {$IFC NOT GENERATINGCFM}
  512.     INLINE $205F, $4E90;
  513.     {$ENDC}
  514.  
  515. PROCEDURE CallQDGetPicProc(dataPtr: Ptr; byteCount: INTEGER; userRoutine: QDGetPicUPP);
  516.     {$IFC NOT GENERATINGCFM}
  517.     INLINE $205F, $4E90;
  518.     {$ENDC}
  519.  
  520. PROCEDURE CallQDPutPicProc(dataPtr: Ptr; byteCount: INTEGER; userRoutine: QDPutPicUPP);
  521.     {$IFC NOT GENERATINGCFM}
  522.     INLINE $205F, $4E90;
  523.     {$ENDC}
  524.  
  525. PROCEDURE CallQDOpcodeProc(VAR fromRect: Rect; VAR toRect: Rect; opcode: INTEGER; version: INTEGER; userRoutine: QDOpcodeUPP);
  526.     {$IFC NOT GENERATINGCFM}
  527.     INLINE $205F, $4E90;
  528.     {$ENDC}
  529.  
  530. PROCEDURE CallQDJShieldCursorProc(left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER; userRoutine: QDJShieldCursorUPP);
  531.     {$IFC NOT GENERATINGCFM}
  532.     INLINE $205F, $4E90;
  533.     {$ENDC}
  534.  
  535. TYPE
  536.     GrafPortPtr = ^GrafPort;
  537.     GrafPort = RECORD
  538.         device:                    INTEGER;
  539.         portBits:                BitMap;
  540.         portRect:                Rect;
  541.         visRgn:                    RgnHandle;
  542.         clipRgn:                RgnHandle;
  543.         bkPat:                    Pattern;
  544.         fillPat:                Pattern;
  545.         pnLoc:                    Point;
  546.         pnSize:                    Point;
  547.         pnMode:                    INTEGER;
  548.         pnPat:                    Pattern;
  549.         pnVis:                    INTEGER;
  550.         txFont:                    INTEGER;
  551.         txFace:                    StyleField;                                { StyleField occupies 16-bits, but only first 8-bits are used }
  552.         txMode:                    INTEGER;
  553.         txSize:                    INTEGER;
  554.         spExtra:                Fixed;
  555.         fgColor:                LONGINT;
  556.         bkColor:                LONGINT;
  557.         colrBit:                INTEGER;
  558.         patStretch:                INTEGER;
  559.         picSave:                Handle;
  560.         rgnSave:                Handle;
  561.         polySave:                Handle;
  562.         grafProcs:                QDProcsPtr;
  563.     END;
  564.  
  565.     GrafPtr                                = ^GrafPort;
  566. {
  567.  *    This set of definitions "belongs" in Windows.
  568.  *    But, there is a circularity in the headers where Windows includes Controls and
  569.  *    Controls includes Windows. To break the circle, the information
  570.  *    needed by Controls is moved from Windows to Quickdraw.
  571. }
  572.     WindowPtr                            = GrafPtr;
  573.     WindowRef                            = WindowPtr;
  574.     DialogPtr                            = WindowPtr;
  575. {  DragConstraint constants to pass to DragGray,DragTheRgn, or ConstrainedDragRgn }
  576.     DragConstraint                        = UInt16;
  577.  
  578. CONST
  579.     kNoConstraint                = 0;
  580.     kVerticalConstraint            = 1;
  581.     kHorizontalConstraint        = 2;
  582.  
  583.  
  584. TYPE
  585.     DragGrayRgnProcPtr = ProcPtr;  { PROCEDURE DragGrayRgn; }
  586.  
  587. {
  588.  *    Here ends the list of things that "belong" in Windows.
  589. }
  590.     ColorSearchProcPtr = ProcPtr;  { FUNCTION ColorSearch(VAR rgb: RGBColor; VAR position: LONGINT): BOOLEAN; }
  591.  
  592.     ColorComplementProcPtr = ProcPtr;  { FUNCTION ColorComplement(VAR rgb: RGBColor): BOOLEAN; }
  593.  
  594.     DragGrayRgnUPP = UniversalProcPtr;
  595.     ColorSearchUPP = UniversalProcPtr;
  596.     ColorComplementUPP = UniversalProcPtr;
  597.  
  598. CONST
  599.     uppDragGrayRgnProcInfo = $00000000;
  600.     uppColorSearchProcInfo = $000003D0;
  601.     uppColorComplementProcInfo = $000000D0;
  602.  
  603. FUNCTION NewDragGrayRgnProc(userRoutine: DragGrayRgnProcPtr): DragGrayRgnUPP;
  604.     {$IFC NOT GENERATINGCFM }
  605.     INLINE $2E9F;
  606.     {$ENDC}
  607.  
  608. FUNCTION NewColorSearchProc(userRoutine: ColorSearchProcPtr): ColorSearchUPP;
  609.     {$IFC NOT GENERATINGCFM }
  610.     INLINE $2E9F;
  611.     {$ENDC}
  612.  
  613. FUNCTION NewColorComplementProc(userRoutine: ColorComplementProcPtr): ColorComplementUPP;
  614.     {$IFC NOT GENERATINGCFM }
  615.     INLINE $2E9F;
  616.     {$ENDC}
  617.  
  618. PROCEDURE CallDragGrayRgnProc(userRoutine: DragGrayRgnUPP);
  619.     {$IFC NOT GENERATINGCFM}
  620.     INLINE $205F, $4E90;
  621.     {$ENDC}
  622.  
  623. FUNCTION CallColorSearchProc(VAR rgb: RGBColor; VAR position: LONGINT; userRoutine: ColorSearchUPP): BOOLEAN;
  624.     {$IFC NOT GENERATINGCFM}
  625.     INLINE $205F, $4E90;
  626.     {$ENDC}
  627.  
  628. FUNCTION CallColorComplementProc(VAR rgb: RGBColor; userRoutine: ColorComplementUPP): BOOLEAN;
  629.     {$IFC NOT GENERATINGCFM}
  630.     INLINE $205F, $4E90;
  631.     {$ENDC}
  632.  
  633. TYPE
  634.     MatchRecPtr = ^MatchRec;
  635.     MatchRec = RECORD
  636.         red:                    INTEGER;
  637.         green:                    INTEGER;
  638.         blue:                    INTEGER;
  639.         matchData:                LONGINT;
  640.     END;
  641.  
  642.     PixMapPtr = ^PixMap;
  643.     PixMap = RECORD
  644.         baseAddr:                Ptr;                                    { pointer to pixels }
  645.         rowBytes:                INTEGER;                                { offset to next line }
  646.         bounds:                    Rect;                                    { encloses bitmap }
  647.         pmVersion:                INTEGER;                                { pixMap version number }
  648.         packType:                INTEGER;                                { defines packing format }
  649.         packSize:                LONGINT;                                { length of pixel data }
  650.         hRes:                    Fixed;                                    { horiz. resolution (ppi) }
  651.         vRes:                    Fixed;                                    { vert. resolution (ppi) }
  652.         pixelType:                INTEGER;                                { defines pixel type }
  653.         pixelSize:                INTEGER;                                { # bits in pixel }
  654.         cmpCount:                INTEGER;                                { # components in pixel }
  655.         cmpSize:                INTEGER;                                { # bits per component }
  656.         planeBytes:                LONGINT;                                { offset to next plane }
  657.         pmTable:                CTabHandle;                                { color map for this pixMap }
  658.         pmReserved:                LONGINT;                                { for future use. MUST BE 0 }
  659.     END;
  660.  
  661.     PixMapHandle                        = ^PixMapPtr;
  662.     PixPatPtr = ^PixPat;
  663.     PixPat = RECORD
  664.         patType:                INTEGER;                                { type of pattern }
  665.         patMap:                    PixMapHandle;                            { the pattern's pixMap }
  666.         patData:                Handle;                                    { pixmap's data }
  667.         patXData:                Handle;                                    { expanded Pattern data }
  668.         patXValid:                INTEGER;                                { flags whether expanded Pattern valid }
  669.         patXMap:                Handle;                                    { Handle to expanded Pattern data }
  670.         pat1Data:                Pattern;                                { old-Style pattern/RGB color }
  671.     END;
  672.  
  673.     PixPatHandle                        = ^PixPatPtr;
  674.     CCrsrPtr = ^CCrsr;
  675.     CCrsr = RECORD
  676.         crsrType:                INTEGER;                                { type of cursor }
  677.         crsrMap:                PixMapHandle;                            { the cursor's pixmap }
  678.         crsrData:                Handle;                                    { cursor's data }
  679.         crsrXData:                Handle;                                    { expanded cursor data }
  680.         crsrXValid:                INTEGER;                                { depth of expanded data (0 if none) }
  681.         crsrXHandle:            Handle;                                    { future use }
  682.         crsr1Data:                Bits16;                                    { one-bit cursor }
  683.         crsrMask:                Bits16;                                    { cursor's mask }
  684.         crsrHotSpot:            Point;                                    { cursor's hotspot }
  685.         crsrXTable:                LONGINT;                                { private }
  686.         crsrID:                    LONGINT;                                { private }
  687.     END;
  688.  
  689.     CCrsrHandle                            = ^CCrsrPtr;
  690. {$IFC OLDROUTINELOCATIONS }
  691.     CIconPtr = ^CIcon;
  692.     CIcon = RECORD
  693.         iconPMap:                PixMap;                                    { the icon's pixMap }
  694.         iconMask:                BitMap;                                    { the icon's mask }
  695.         iconBMap:                BitMap;                                    { the icon's bitMap }
  696.         iconData:                Handle;                                    { the icon's data }
  697.         iconMaskData:            ARRAY [0..0] OF INTEGER;                { icon's mask and BitMap data }
  698.     END;
  699.  
  700.     CIconHandle                            = ^CIconPtr;
  701. {$ENDC}
  702.     ITabPtr = ^ITab;
  703.     ITab = RECORD
  704.         iTabSeed:                LONGINT;                                { copy of CTSeed from source CTable }
  705.         iTabRes:                INTEGER;                                { bits/channel resolution of iTable }
  706.         iTTable:                SInt8;                                    { byte colortable index values }
  707.     END;
  708.  
  709.     ITabHandle                            = ^ITabPtr;
  710.     SProcRecPtr = ^SProcRec;
  711.     SProcRec = RECORD
  712.         nxtSrch:                Handle;                                    { SProcHndl Handle to next SProcRec }
  713.         srchProc:                ColorSearchUPP;                            { search procedure proc ptr }
  714.     END;
  715.  
  716.     SProcPtr                            = ^SProcRec;
  717.     SProcHndl                            = ^SProcPtr;
  718.     CProcRecPtr = ^CProcRec;
  719.     CProcRec = RECORD
  720.         nxtComp:                Handle;                                    { CProcHndl Handle to next CProcRec }
  721.         compProc:                ColorComplementUPP;                        { complement procedure proc ptr }
  722.     END;
  723.  
  724.     CProcPtr                            = ^CProcRec;
  725.     CProcHndl                            = ^CProcPtr;
  726.     GDevicePtr = ^GDevice;
  727.     GDevice = RECORD
  728.         gdRefNum:                INTEGER;                                { driver's unit number }
  729.         gdID:                    INTEGER;                                { client ID for search procs }
  730.         gdType:                    INTEGER;                                { fixed/CLUT/direct }
  731.         gdITable:                ITabHandle;                                { Handle to inverse lookup table }
  732.         gdResPref:                INTEGER;                                { preferred resolution of GDITable }
  733.         gdSearchProc:            SProcHndl;                                { search proc list head }
  734.         gdCompProc:                CProcHndl;                                { complement proc list }
  735.         gdFlags:                INTEGER;                                { grafDevice flags word }
  736.         gdPMap:                    PixMapHandle;                            { describing pixMap }
  737.         gdRefCon:                LONGINT;                                { reference value }
  738.         gdNextGD:                Handle;                                    { GDHandle Handle of next gDevice }
  739.         gdRect:                    Rect;                                    {  device's bounds in global coordinates }
  740.         gdMode:                    LONGINT;                                { device's current mode }
  741.         gdCCBytes:                INTEGER;                                { depth of expanded cursor data }
  742.         gdCCDepth:                INTEGER;                                { depth of expanded cursor data }
  743.         gdCCXData:                Handle;                                    { Handle to cursor's expanded data }
  744.         gdCCXMask:                Handle;                                    { Handle to cursor's expanded mask }
  745.         gdReserved:                LONGINT;                                { future use. MUST BE 0 }
  746.     END;
  747.  
  748.     GDPtr                                = ^GDevice;
  749.     GDHandle                            = ^GDPtr;
  750.     GrafVarsPtr = ^GrafVars;
  751.     GrafVars = RECORD
  752.         rgbOpColor:                RGBColor;                                { color for addPin  subPin and average }
  753.         rgbHiliteColor:            RGBColor;                                { color for hiliting }
  754.         pmFgColor:                Handle;                                    { palette Handle for foreground color }
  755.         pmFgIndex:                INTEGER;                                { index value for foreground }
  756.         pmBkColor:                Handle;                                    { palette Handle for background color }
  757.         pmBkIndex:                INTEGER;                                { index value for background }
  758.         pmFlags:                INTEGER;                                { flags for Palette Manager }
  759.     END;
  760.  
  761.     GVarPtr                                = ^GrafVars;
  762.     GVarHandle                            = ^GVarPtr;
  763.     CQDProcsPtr = ^CQDProcs;
  764.     CQDProcs = RECORD
  765.         textProc:                QDTextUPP;
  766.         lineProc:                QDLineUPP;
  767.         rectProc:                QDRectUPP;
  768.         rRectProc:                QDRRectUPP;
  769.         ovalProc:                QDOvalUPP;
  770.         arcProc:                QDArcUPP;
  771.         polyProc:                QDPolyUPP;
  772.         rgnProc:                QDRgnUPP;
  773.         bitsProc:                QDBitsUPP;
  774.         commentProc:            QDCommentUPP;
  775.         txMeasProc:                QDTxMeasUPP;
  776.         getPicProc:                QDGetPicUPP;
  777.         putPicProc:                QDPutPicUPP;
  778.         opcodeProc:                QDOpcodeUPP;                            { fields added to QDProcs }
  779.         newProc1:                UniversalProcPtr;
  780.         newProc2:                UniversalProcPtr;
  781.         newProc3:                UniversalProcPtr;
  782.         newProc4:                UniversalProcPtr;
  783.         newProc5:                UniversalProcPtr;
  784.         newProc6:                UniversalProcPtr;
  785.     END;
  786.  
  787.     CGrafPortPtr = ^CGrafPort;
  788.     CGrafPort = RECORD
  789.         device:                    INTEGER;
  790.         portPixMap:                PixMapHandle;                            { port's pixel map }
  791.         portVersion:            INTEGER;                                { high 2 bits always set }
  792.         grafVars:                Handle;                                    { Handle to more fields }
  793.         chExtra:                INTEGER;                                { character extra }
  794.         pnLocHFrac:                INTEGER;                                { pen fraction }
  795.         portRect:                Rect;
  796.         visRgn:                    RgnHandle;
  797.         clipRgn:                RgnHandle;
  798.         bkPixPat:                PixPatHandle;                            { background pattern }
  799.         rgbFgColor:                RGBColor;                                { RGB components of fg }
  800.         rgbBkColor:                RGBColor;                                { RGB components of bk }
  801.         pnLoc:                    Point;
  802.         pnSize:                    Point;
  803.         pnMode:                    INTEGER;
  804.         pnPixPat:                PixPatHandle;                            { pen's pattern }
  805.         fillPixPat:                PixPatHandle;                            { fill pattern }
  806.         pnVis:                    INTEGER;
  807.         txFont:                    INTEGER;
  808.         txFace:                    StyleField;                                { StyleField occupies 16-bits, but only first 8-bits are used }
  809.         txMode:                    INTEGER;
  810.         txSize:                    INTEGER;
  811.         spExtra:                Fixed;
  812.         fgColor:                LONGINT;
  813.         bkColor:                LONGINT;
  814.         colrBit:                INTEGER;
  815.         patStretch:                INTEGER;
  816.         picSave:                Handle;
  817.         rgnSave:                Handle;
  818.         polySave:                Handle;
  819.         grafProcs:                CQDProcsPtr;
  820.     END;
  821.  
  822.     CGrafPtr                            = ^CGrafPort;
  823.     CWindowPtr                            = CGrafPtr;
  824.     ReqListRecPtr = ^ReqListRec;
  825.     ReqListRec = RECORD
  826.         reqLSize:                INTEGER;                                { request list size }
  827.         reqLData:                ARRAY [0..0] OF INTEGER;                { request list data }
  828.     END;
  829.  
  830.     OpenCPicParamsPtr = ^OpenCPicParams;
  831.     OpenCPicParams = RECORD
  832.         srcRect:                Rect;
  833.         hRes:                    Fixed;
  834.         vRes:                    Fixed;
  835.         version:                INTEGER;
  836.         reserved1:                INTEGER;
  837.         reserved2:                LONGINT;
  838.     END;
  839.  
  840.  
  841. CONST
  842.     kCursorImageMajorVersion    = $0001;
  843.     kCursorImageMinorVersion    = $0000;
  844.  
  845.  
  846. TYPE
  847.     CursorImageRecPtr = ^CursorImageRec;
  848.     CursorImageRec = RECORD
  849.         majorVersion:            UInt16;
  850.         minorVersion:            UInt16;
  851.         cursorPixMap:            PixMapHandle;
  852.         cursorBitMask:            BitMapHandle;
  853.     END;
  854.  
  855.     CursorImagePtr                        = ^CursorImageRec;
  856.     DeviceLoopDrawingProcPtr = ProcPtr;  { PROCEDURE DeviceLoopDrawing(depth: INTEGER; deviceFlags: INTEGER; targetDevice: GDHandle; userData: LONGINT); }
  857.  
  858.     DeviceLoopDrawingUPP = UniversalProcPtr;
  859.  
  860. CONST
  861.     uppDeviceLoopDrawingProcInfo = $00003E80;
  862.  
  863. FUNCTION NewDeviceLoopDrawingProc(userRoutine: DeviceLoopDrawingProcPtr): DeviceLoopDrawingUPP;
  864.     {$IFC NOT GENERATINGCFM }
  865.     INLINE $2E9F;
  866.     {$ENDC}
  867.  
  868. PROCEDURE CallDeviceLoopDrawingProc(depth: INTEGER; deviceFlags: INTEGER; targetDevice: GDHandle; userData: LONGINT; userRoutine: DeviceLoopDrawingUPP);
  869.     {$IFC NOT GENERATINGCFM}
  870.     INLINE $205F, $4E90;
  871.     {$ENDC}
  872. {$IFC FOR_SYSTEM8_COOPERATIVE }
  873.  
  874. TYPE
  875.     NativeDeviceLoopDrawingProcPtr        = DeviceLoopDrawingProcPtr;
  876. {$ENDC}
  877.  
  878. TYPE
  879.     QDGlobalsPtr = ^QDGlobals;
  880.     QDGlobals = RECORD
  881.         privates:                PACKED ARRAY [0..75] OF CHAR;
  882.         randSeed:                LONGINT;
  883.         screenBits:                BitMap;
  884.         arrow:                    Cursor;
  885.         dkGray:                    Pattern;
  886.         ltGray:                    Pattern;
  887.         gray:                    Pattern;
  888.         black:                    Pattern;
  889.         white:                    Pattern;
  890.         thePort:                GrafPtr;
  891.     END;
  892.  
  893.     QDGlobalsHdl                        = ^QDGlobalsPtr;
  894.  
  895. { To be in sync with the C interface to QuickDraw globals, pascal code must now }
  896. { qualify the QuickDraw globals with “qd.” (e.g. InitGraf(@qd.thePort);  )       }
  897. VAR
  898.     {$PUSH}
  899.     {$J+}
  900.     qd: QDGlobals;
  901.     {$POP}
  902. PROCEDURE InitGraf(globalPtr: UNIV Ptr);
  903.     {$IFC NOT GENERATINGCFM}
  904.     INLINE $A86E;
  905.     {$ENDC}
  906. PROCEDURE OpenPort(port: GrafPtr);
  907.     {$IFC NOT GENERATINGCFM}
  908.     INLINE $A86F;
  909.     {$ENDC}
  910. PROCEDURE InitPort(port: GrafPtr);
  911.     {$IFC NOT GENERATINGCFM}
  912.     INLINE $A86D;
  913.     {$ENDC}
  914. PROCEDURE ClosePort(port: GrafPtr);
  915.     {$IFC NOT GENERATINGCFM}
  916.     INLINE $A87D;
  917.     {$ENDC}
  918. PROCEDURE SetPort(port: GrafPtr);
  919.     {$IFC NOT GENERATINGCFM}
  920.     INLINE $A873;
  921.     {$ENDC}
  922. PROCEDURE GetPort(VAR port: GrafPtr);
  923.     {$IFC NOT GENERATINGCFM}
  924.     INLINE $A874;
  925.     {$ENDC}
  926. PROCEDURE GrafDevice(device: INTEGER);
  927.     {$IFC NOT GENERATINGCFM}
  928.     INLINE $A872;
  929.     {$ENDC}
  930. PROCEDURE SetPortBits({CONST}VAR bm: BitMap);
  931.     {$IFC NOT GENERATINGCFM}
  932.     INLINE $A875;
  933.     {$ENDC}
  934. PROCEDURE PortSize(width: INTEGER; height: INTEGER);
  935.     {$IFC NOT GENERATINGCFM}
  936.     INLINE $A876;
  937.     {$ENDC}
  938. PROCEDURE MovePortTo(leftGlobal: INTEGER; topGlobal: INTEGER);
  939.     {$IFC NOT GENERATINGCFM}
  940.     INLINE $A877;
  941.     {$ENDC}
  942. PROCEDURE SetOrigin(h: INTEGER; v: INTEGER);
  943.     {$IFC NOT GENERATINGCFM}
  944.     INLINE $A878;
  945.     {$ENDC}
  946. PROCEDURE SetClip(rgn: RgnHandle);
  947.     {$IFC NOT GENERATINGCFM}
  948.     INLINE $A879;
  949.     {$ENDC}
  950. PROCEDURE GetClip(rgn: RgnHandle);
  951.     {$IFC NOT GENERATINGCFM}
  952.     INLINE $A87A;
  953.     {$ENDC}
  954. PROCEDURE ClipRect({CONST}VAR r: Rect);
  955.     {$IFC NOT GENERATINGCFM}
  956.     INLINE $A87B;
  957.     {$ENDC}
  958. PROCEDURE BackPat({CONST}VAR pat: Pattern);
  959.     {$IFC NOT GENERATINGCFM}
  960.     INLINE $A87C;
  961.     {$ENDC}
  962. PROCEDURE InitCursor;
  963.     {$IFC NOT GENERATINGCFM}
  964.     INLINE $A850;
  965.     {$ENDC}
  966. PROCEDURE SetCursor({CONST}VAR crsr: Cursor);
  967.     {$IFC NOT GENERATINGCFM}
  968.     INLINE $A851;
  969.     {$ENDC}
  970. PROCEDURE HideCursor;
  971.     {$IFC NOT GENERATINGCFM}
  972.     INLINE $A852;
  973.     {$ENDC}
  974. PROCEDURE ShowCursor;
  975.     {$IFC NOT GENERATINGCFM}
  976.     INLINE $A853;
  977.     {$ENDC}
  978. PROCEDURE ObscureCursor;
  979.     {$IFC NOT GENERATINGCFM}
  980.     INLINE $A856;
  981.     {$ENDC}
  982. PROCEDURE HidePen;
  983.     {$IFC NOT GENERATINGCFM}
  984.     INLINE $A896;
  985.     {$ENDC}
  986. PROCEDURE ShowPen;
  987.     {$IFC NOT GENERATINGCFM}
  988.     INLINE $A897;
  989.     {$ENDC}
  990. PROCEDURE GetPen(VAR pt: Point);
  991.     {$IFC NOT GENERATINGCFM}
  992.     INLINE $A89A;
  993.     {$ENDC}
  994. PROCEDURE GetPenState(VAR pnState: PenState);
  995.     {$IFC NOT GENERATINGCFM}
  996.     INLINE $A898;
  997.     {$ENDC}
  998. PROCEDURE SetPenState({CONST}VAR pnState: PenState);
  999.     {$IFC NOT GENERATINGCFM}
  1000.     INLINE $A899;
  1001.     {$ENDC}
  1002. PROCEDURE PenSize(width: INTEGER; height: INTEGER);
  1003.     {$IFC NOT GENERATINGCFM}
  1004.     INLINE $A89B;
  1005.     {$ENDC}
  1006. PROCEDURE PenMode(mode: INTEGER);
  1007.     {$IFC NOT GENERATINGCFM}
  1008.     INLINE $A89C;
  1009.     {$ENDC}
  1010. PROCEDURE PenPat({CONST}VAR pat: Pattern);
  1011.     {$IFC NOT GENERATINGCFM}
  1012.     INLINE $A89D;
  1013.     {$ENDC}
  1014. PROCEDURE PenNormal;
  1015.     {$IFC NOT GENERATINGCFM}
  1016.     INLINE $A89E;
  1017.     {$ENDC}
  1018. PROCEDURE MoveTo(h: INTEGER; v: INTEGER);
  1019.     {$IFC NOT GENERATINGCFM}
  1020.     INLINE $A893;
  1021.     {$ENDC}
  1022. PROCEDURE Move(dh: INTEGER; dv: INTEGER);
  1023.     {$IFC NOT GENERATINGCFM}
  1024.     INLINE $A894;
  1025.     {$ENDC}
  1026. PROCEDURE LineTo(h: INTEGER; v: INTEGER);
  1027.     {$IFC NOT GENERATINGCFM}
  1028.     INLINE $A891;
  1029.     {$ENDC}
  1030. PROCEDURE Line(dh: INTEGER; dv: INTEGER);
  1031.     {$IFC NOT GENERATINGCFM}
  1032.     INLINE $A892;
  1033.     {$ENDC}
  1034. PROCEDURE ForeColor(color: LONGINT);
  1035.     {$IFC NOT GENERATINGCFM}
  1036.     INLINE $A862;
  1037.     {$ENDC}
  1038. PROCEDURE BackColor(color: LONGINT);
  1039.     {$IFC NOT GENERATINGCFM}
  1040.     INLINE $A863;
  1041.     {$ENDC}
  1042. PROCEDURE ColorBit(whichBit: INTEGER);
  1043.     {$IFC NOT GENERATINGCFM}
  1044.     INLINE $A864;
  1045.     {$ENDC}
  1046. PROCEDURE SetRect(VAR r: Rect; left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER);
  1047.     {$IFC NOT GENERATINGCFM}
  1048.     INLINE $A8A7;
  1049.     {$ENDC}
  1050. PROCEDURE OffsetRect(VAR r: Rect; dh: INTEGER; dv: INTEGER);
  1051.     {$IFC NOT GENERATINGCFM}
  1052.     INLINE $A8A8;
  1053.     {$ENDC}
  1054. PROCEDURE InsetRect(VAR r: Rect; dh: INTEGER; dv: INTEGER);
  1055.     {$IFC NOT GENERATINGCFM}
  1056.     INLINE $A8A9;
  1057.     {$ENDC}
  1058. FUNCTION SectRect({CONST}VAR src1: Rect; {CONST}VAR src2: Rect; VAR dstRect: Rect): BOOLEAN;
  1059.     {$IFC NOT GENERATINGCFM}
  1060.     INLINE $A8AA;
  1061.     {$ENDC}
  1062. PROCEDURE UnionRect({CONST}VAR src1: Rect; {CONST}VAR src2: Rect; VAR dstRect: Rect);
  1063.     {$IFC NOT GENERATINGCFM}
  1064.     INLINE $A8AB;
  1065.     {$ENDC}
  1066. FUNCTION EqualRect({CONST}VAR rect1: Rect; {CONST}VAR rect2: Rect): BOOLEAN;
  1067.     {$IFC NOT GENERATINGCFM}
  1068.     INLINE $A8A6;
  1069.     {$ENDC}
  1070. FUNCTION EmptyRect({CONST}VAR r: Rect): BOOLEAN;
  1071.     {$IFC NOT GENERATINGCFM}
  1072.     INLINE $A8AE;
  1073.     {$ENDC}
  1074. PROCEDURE FrameRect({CONST}VAR r: Rect);
  1075.     {$IFC NOT GENERATINGCFM}
  1076.     INLINE $A8A1;
  1077.     {$ENDC}
  1078. PROCEDURE PaintRect({CONST}VAR r: Rect);
  1079.     {$IFC NOT GENERATINGCFM}
  1080.     INLINE $A8A2;
  1081.     {$ENDC}
  1082. PROCEDURE EraseRect({CONST}VAR r: Rect);
  1083.     {$IFC NOT GENERATINGCFM}
  1084.     INLINE $A8A3;
  1085.     {$ENDC}
  1086. PROCEDURE InvertRect({CONST}VAR r: Rect);
  1087.     {$IFC NOT GENERATINGCFM}
  1088.     INLINE $A8A4;
  1089.     {$ENDC}
  1090. PROCEDURE FillRect({CONST}VAR r: Rect; {CONST}VAR pat: Pattern);
  1091.     {$IFC NOT GENERATINGCFM}
  1092.     INLINE $A8A5;
  1093.     {$ENDC}
  1094. PROCEDURE FrameOval({CONST}VAR r: Rect);
  1095.     {$IFC NOT GENERATINGCFM}
  1096.     INLINE $A8B7;
  1097.     {$ENDC}
  1098. PROCEDURE PaintOval({CONST}VAR r: Rect);
  1099.     {$IFC NOT GENERATINGCFM}
  1100.     INLINE $A8B8;
  1101.     {$ENDC}
  1102. PROCEDURE EraseOval({CONST}VAR r: Rect);
  1103.     {$IFC NOT GENERATINGCFM}
  1104.     INLINE $A8B9;
  1105.     {$ENDC}
  1106. PROCEDURE InvertOval({CONST}VAR r: Rect);
  1107.     {$IFC NOT GENERATINGCFM}
  1108.     INLINE $A8BA;
  1109.     {$ENDC}
  1110. PROCEDURE FillOval({CONST}VAR r: Rect; {CONST}VAR pat: Pattern);
  1111.     {$IFC NOT GENERATINGCFM}
  1112.     INLINE $A8BB;
  1113.     {$ENDC}
  1114. PROCEDURE FrameRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1115.     {$IFC NOT GENERATINGCFM}
  1116.     INLINE $A8B0;
  1117.     {$ENDC}
  1118. PROCEDURE PaintRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1119.     {$IFC NOT GENERATINGCFM}
  1120.     INLINE $A8B1;
  1121.     {$ENDC}
  1122. PROCEDURE EraseRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1123.     {$IFC NOT GENERATINGCFM}
  1124.     INLINE $A8B2;
  1125.     {$ENDC}
  1126. PROCEDURE InvertRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1127.     {$IFC NOT GENERATINGCFM}
  1128.     INLINE $A8B3;
  1129.     {$ENDC}
  1130. PROCEDURE FillRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER; {CONST}VAR pat: Pattern);
  1131.     {$IFC NOT GENERATINGCFM}
  1132.     INLINE $A8B4;
  1133.     {$ENDC}
  1134. PROCEDURE FrameArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1135.     {$IFC NOT GENERATINGCFM}
  1136.     INLINE $A8BE;
  1137.     {$ENDC}
  1138. PROCEDURE PaintArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1139.     {$IFC NOT GENERATINGCFM}
  1140.     INLINE $A8BF;
  1141.     {$ENDC}
  1142. PROCEDURE EraseArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1143.     {$IFC NOT GENERATINGCFM}
  1144.     INLINE $A8C0;
  1145.     {$ENDC}
  1146. PROCEDURE InvertArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1147.     {$IFC NOT GENERATINGCFM}
  1148.     INLINE $A8C1;
  1149.     {$ENDC}
  1150. PROCEDURE FillArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER; {CONST}VAR pat: Pattern);
  1151.     {$IFC NOT GENERATINGCFM}
  1152.     INLINE $A8C2;
  1153.     {$ENDC}
  1154. FUNCTION NewRgn: RgnHandle;
  1155.     {$IFC NOT GENERATINGCFM}
  1156.     INLINE $A8D8;
  1157.     {$ENDC}
  1158. PROCEDURE OpenRgn;
  1159.     {$IFC NOT GENERATINGCFM}
  1160.     INLINE $A8DA;
  1161.     {$ENDC}
  1162. PROCEDURE CloseRgn(dstRgn: RgnHandle);
  1163.     {$IFC NOT GENERATINGCFM}
  1164.     INLINE $A8DB;
  1165.     {$ENDC}
  1166. FUNCTION BitMapToRegion(region: RgnHandle; {CONST}VAR bMap: BitMap): OSErr;
  1167.     {$IFC NOT GENERATINGCFM}
  1168.     INLINE $A8D7;
  1169.     {$ENDC}
  1170. PROCEDURE DisposeRgn(rgn: RgnHandle);
  1171.     {$IFC NOT GENERATINGCFM}
  1172.     INLINE $A8D9;
  1173.     {$ENDC}
  1174. PROCEDURE CopyRgn(srcRgn: RgnHandle; dstRgn: RgnHandle);
  1175.     {$IFC NOT GENERATINGCFM}
  1176.     INLINE $A8DC;
  1177.     {$ENDC}
  1178. PROCEDURE SetEmptyRgn(rgn: RgnHandle);
  1179.     {$IFC NOT GENERATINGCFM}
  1180.     INLINE $A8DD;
  1181.     {$ENDC}
  1182. PROCEDURE SetRectRgn(rgn: RgnHandle; left: INTEGER; top: INTEGER; right: INTEGER; bottom: INTEGER);
  1183.     {$IFC NOT GENERATINGCFM}
  1184.     INLINE $A8DE;
  1185.     {$ENDC}
  1186. PROCEDURE RectRgn(rgn: RgnHandle; {CONST}VAR r: Rect);
  1187.     {$IFC NOT GENERATINGCFM}
  1188.     INLINE $A8DF;
  1189.     {$ENDC}
  1190. PROCEDURE OffsetRgn(rgn: RgnHandle; dh: INTEGER; dv: INTEGER);
  1191.     {$IFC NOT GENERATINGCFM}
  1192.     INLINE $A8E0;
  1193.     {$ENDC}
  1194. PROCEDURE InsetRgn(rgn: RgnHandle; dh: INTEGER; dv: INTEGER);
  1195.     {$IFC NOT GENERATINGCFM}
  1196.     INLINE $A8E1;
  1197.     {$ENDC}
  1198. PROCEDURE SectRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1199.     {$IFC NOT GENERATINGCFM}
  1200.     INLINE $A8E4;
  1201.     {$ENDC}
  1202. PROCEDURE UnionRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1203.     {$IFC NOT GENERATINGCFM}
  1204.     INLINE $A8E5;
  1205.     {$ENDC}
  1206. PROCEDURE DiffRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1207.     {$IFC NOT GENERATINGCFM}
  1208.     INLINE $A8E6;
  1209.     {$ENDC}
  1210. PROCEDURE XorRgn(srcRgnA: RgnHandle; srcRgnB: RgnHandle; dstRgn: RgnHandle);
  1211.     {$IFC NOT GENERATINGCFM}
  1212.     INLINE $A8E7;
  1213.     {$ENDC}
  1214. FUNCTION RectInRgn({CONST}VAR r: Rect; rgn: RgnHandle): BOOLEAN;
  1215.     {$IFC NOT GENERATINGCFM}
  1216.     INLINE $A8E9;
  1217.     {$ENDC}
  1218. FUNCTION EqualRgn(rgnA: RgnHandle; rgnB: RgnHandle): BOOLEAN;
  1219.     {$IFC NOT GENERATINGCFM}
  1220.     INLINE $A8E3;
  1221.     {$ENDC}
  1222. FUNCTION EmptyRgn(rgn: RgnHandle): BOOLEAN;
  1223.     {$IFC NOT GENERATINGCFM}
  1224.     INLINE $A8E2;
  1225.     {$ENDC}
  1226. PROCEDURE FrameRgn(rgn: RgnHandle);
  1227.     {$IFC NOT GENERATINGCFM}
  1228.     INLINE $A8D2;
  1229.     {$ENDC}
  1230. PROCEDURE PaintRgn(rgn: RgnHandle);
  1231.     {$IFC NOT GENERATINGCFM}
  1232.     INLINE $A8D3;
  1233.     {$ENDC}
  1234. PROCEDURE EraseRgn(rgn: RgnHandle);
  1235.     {$IFC NOT GENERATINGCFM}
  1236.     INLINE $A8D4;
  1237.     {$ENDC}
  1238. PROCEDURE InvertRgn(rgn: RgnHandle);
  1239.     {$IFC NOT GENERATINGCFM}
  1240.     INLINE $A8D5;
  1241.     {$ENDC}
  1242. PROCEDURE FillRgn(rgn: RgnHandle; {CONST}VAR pat: Pattern);
  1243.     {$IFC NOT GENERATINGCFM}
  1244.     INLINE $A8D6;
  1245.     {$ENDC}
  1246. PROCEDURE ScrollRect({CONST}VAR r: Rect; dh: INTEGER; dv: INTEGER; updateRgn: RgnHandle);
  1247.     {$IFC NOT GENERATINGCFM}
  1248.     INLINE $A8EF;
  1249.     {$ENDC}
  1250. PROCEDURE CopyBits({CONST}VAR srcBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle);
  1251.     {$IFC NOT GENERATINGCFM}
  1252.     INLINE $A8EC;
  1253.     {$ENDC}
  1254. PROCEDURE SeedFill(srcPtr: UNIV Ptr; dstPtr: UNIV Ptr; srcRow: INTEGER; dstRow: INTEGER; height: INTEGER; words: INTEGER; seedH: INTEGER; seedV: INTEGER);
  1255.     {$IFC NOT GENERATINGCFM}
  1256.     INLINE $A839;
  1257.     {$ENDC}
  1258. PROCEDURE CalcMask(srcPtr: UNIV Ptr; dstPtr: UNIV Ptr; srcRow: INTEGER; dstRow: INTEGER; height: INTEGER; words: INTEGER);
  1259.     {$IFC NOT GENERATINGCFM}
  1260.     INLINE $A838;
  1261.     {$ENDC}
  1262. PROCEDURE CopyMask({CONST}VAR srcBits: BitMap; {CONST}VAR maskBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR maskRect: Rect; {CONST}VAR dstRect: Rect);
  1263.     {$IFC NOT GENERATINGCFM}
  1264.     INLINE $A817;
  1265.     {$ENDC}
  1266. FUNCTION OpenPicture({CONST}VAR picFrame: Rect): PicHandle;
  1267.     {$IFC NOT GENERATINGCFM}
  1268.     INLINE $A8F3;
  1269.     {$ENDC}
  1270. PROCEDURE PicComment(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle);
  1271.     {$IFC NOT GENERATINGCFM}
  1272.     INLINE $A8F2;
  1273.     {$ENDC}
  1274. PROCEDURE ClosePicture;
  1275.     {$IFC NOT GENERATINGCFM}
  1276.     INLINE $A8F4;
  1277.     {$ENDC}
  1278. PROCEDURE DrawPicture(myPicture: PicHandle; {CONST}VAR dstRect: Rect);
  1279.     {$IFC NOT GENERATINGCFM}
  1280.     INLINE $A8F6;
  1281.     {$ENDC}
  1282. PROCEDURE KillPicture(myPicture: PicHandle);
  1283.     {$IFC NOT GENERATINGCFM}
  1284.     INLINE $A8F5;
  1285.     {$ENDC}
  1286. FUNCTION OpenPoly: PolyHandle;
  1287.     {$IFC NOT GENERATINGCFM}
  1288.     INLINE $A8CB;
  1289.     {$ENDC}
  1290. PROCEDURE ClosePoly;
  1291.     {$IFC NOT GENERATINGCFM}
  1292.     INLINE $A8CC;
  1293.     {$ENDC}
  1294. PROCEDURE KillPoly(poly: PolyHandle);
  1295.     {$IFC NOT GENERATINGCFM}
  1296.     INLINE $A8CD;
  1297.     {$ENDC}
  1298. PROCEDURE OffsetPoly(poly: PolyHandle; dh: INTEGER; dv: INTEGER);
  1299.     {$IFC NOT GENERATINGCFM}
  1300.     INLINE $A8CE;
  1301.     {$ENDC}
  1302. PROCEDURE FramePoly(poly: PolyHandle);
  1303.     {$IFC NOT GENERATINGCFM}
  1304.     INLINE $A8C6;
  1305.     {$ENDC}
  1306. PROCEDURE PaintPoly(poly: PolyHandle);
  1307.     {$IFC NOT GENERATINGCFM}
  1308.     INLINE $A8C7;
  1309.     {$ENDC}
  1310. PROCEDURE ErasePoly(poly: PolyHandle);
  1311.     {$IFC NOT GENERATINGCFM}
  1312.     INLINE $A8C8;
  1313.     {$ENDC}
  1314. PROCEDURE InvertPoly(poly: PolyHandle);
  1315.     {$IFC NOT GENERATINGCFM}
  1316.     INLINE $A8C9;
  1317.     {$ENDC}
  1318. PROCEDURE FillPoly(poly: PolyHandle; {CONST}VAR pat: Pattern);
  1319.     {$IFC NOT GENERATINGCFM}
  1320.     INLINE $A8CA;
  1321.     {$ENDC}
  1322. PROCEDURE SetPt(VAR pt: Point; h: INTEGER; v: INTEGER);
  1323.     {$IFC NOT GENERATINGCFM}
  1324.     INLINE $A880;
  1325.     {$ENDC}
  1326. PROCEDURE LocalToGlobal(VAR pt: Point);
  1327.     {$IFC NOT GENERATINGCFM}
  1328.     INLINE $A870;
  1329.     {$ENDC}
  1330. PROCEDURE GlobalToLocal(VAR pt: Point);
  1331.     {$IFC NOT GENERATINGCFM}
  1332.     INLINE $A871;
  1333.     {$ENDC}
  1334. FUNCTION Random: INTEGER;
  1335.     {$IFC NOT GENERATINGCFM}
  1336.     INLINE $A861;
  1337.     {$ENDC}
  1338. PROCEDURE StuffHex(thingPtr: UNIV Ptr; s: Str255);
  1339.     {$IFC NOT GENERATINGCFM}
  1340.     INLINE $A866;
  1341.     {$ENDC}
  1342. FUNCTION GetPixel(h: INTEGER; v: INTEGER): BOOLEAN;
  1343.     {$IFC NOT GENERATINGCFM}
  1344.     INLINE $A865;
  1345.     {$ENDC}
  1346. PROCEDURE ScalePt(VAR pt: Point; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1347.     {$IFC NOT GENERATINGCFM}
  1348.     INLINE $A8F8;
  1349.     {$ENDC}
  1350. PROCEDURE MapPt(VAR pt: Point; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1351.     {$IFC NOT GENERATINGCFM}
  1352.     INLINE $A8F9;
  1353.     {$ENDC}
  1354. PROCEDURE MapRect(VAR r: Rect; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1355.     {$IFC NOT GENERATINGCFM}
  1356.     INLINE $A8FA;
  1357.     {$ENDC}
  1358. PROCEDURE MapRgn(rgn: RgnHandle; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1359.     {$IFC NOT GENERATINGCFM}
  1360.     INLINE $A8FB;
  1361.     {$ENDC}
  1362. PROCEDURE MapPoly(poly: PolyHandle; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect);
  1363.     {$IFC NOT GENERATINGCFM}
  1364.     INLINE $A8FC;
  1365.     {$ENDC}
  1366. PROCEDURE SetStdProcs(VAR procs: QDProcs);
  1367.     {$IFC NOT GENERATINGCFM}
  1368.     INLINE $A8EA;
  1369.     {$ENDC}
  1370. PROCEDURE StdRect(verb: GrafVerb; {CONST}VAR r: Rect);
  1371.     {$IFC NOT GENERATINGCFM}
  1372.     INLINE $A8A0;
  1373.     {$ENDC}
  1374. PROCEDURE StdRRect(verb: GrafVerb; {CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER);
  1375.     {$IFC NOT GENERATINGCFM}
  1376.     INLINE $A8AF;
  1377.     {$ENDC}
  1378. PROCEDURE StdOval(verb: GrafVerb; {CONST}VAR r: Rect);
  1379.     {$IFC NOT GENERATINGCFM}
  1380.     INLINE $A8B6;
  1381.     {$ENDC}
  1382. PROCEDURE StdArc(verb: GrafVerb; {CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER);
  1383.     {$IFC NOT GENERATINGCFM}
  1384.     INLINE $A8BD;
  1385.     {$ENDC}
  1386. PROCEDURE StdPoly(verb: GrafVerb; poly: PolyHandle);
  1387.     {$IFC NOT GENERATINGCFM}
  1388.     INLINE $A8C5;
  1389.     {$ENDC}
  1390. PROCEDURE StdRgn(verb: GrafVerb; rgn: RgnHandle);
  1391.     {$IFC NOT GENERATINGCFM}
  1392.     INLINE $A8D1;
  1393.     {$ENDC}
  1394. PROCEDURE StdBits({CONST}VAR srcBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle);
  1395.     {$IFC NOT GENERATINGCFM}
  1396.     INLINE $A8EB;
  1397.     {$ENDC}
  1398. PROCEDURE StdComment(kind: INTEGER; dataSize: INTEGER; dataHandle: Handle);
  1399.     {$IFC NOT GENERATINGCFM}
  1400.     INLINE $A8F1;
  1401.     {$ENDC}
  1402. PROCEDURE StdGetPic(dataPtr: UNIV Ptr; byteCount: INTEGER);
  1403.     {$IFC NOT GENERATINGCFM}
  1404.     INLINE $A8EE;
  1405.     {$ENDC}
  1406. PROCEDURE StdPutPic(dataPtr: UNIV Ptr; byteCount: INTEGER);
  1407.     {$IFC NOT GENERATINGCFM}
  1408.     INLINE $A8F0;
  1409.     {$ENDC}
  1410. PROCEDURE StdOpcode({CONST}VAR fromRect: Rect; {CONST}VAR toRect: Rect; opcode: UInt16; version: SInt16);
  1411.     {$IFC NOT GENERATINGCFM}
  1412.     INLINE $ABF8;
  1413.     {$ENDC}
  1414. PROCEDURE AddPt(src: Point; VAR dst: Point);
  1415.     {$IFC NOT GENERATINGCFM}
  1416.     INLINE $A87E;
  1417.     {$ENDC}
  1418. FUNCTION EqualPt(pt1: Point; pt2: Point): BOOLEAN;
  1419.     {$IFC NOT GENERATINGCFM}
  1420.     INLINE $A881;
  1421.     {$ENDC}
  1422. FUNCTION PtInRect(pt: Point; {CONST}VAR r: Rect): BOOLEAN;
  1423.     {$IFC NOT GENERATINGCFM}
  1424.     INLINE $A8AD;
  1425.     {$ENDC}
  1426. PROCEDURE Pt2Rect(pt1: Point; pt2: Point; VAR dstRect: Rect);
  1427.     {$IFC NOT GENERATINGCFM}
  1428.     INLINE $A8AC;
  1429.     {$ENDC}
  1430. PROCEDURE PtToAngle({CONST}VAR r: Rect; pt: Point; VAR angle: INTEGER);
  1431.     {$IFC NOT GENERATINGCFM}
  1432.     INLINE $A8C3;
  1433.     {$ENDC}
  1434. PROCEDURE SubPt(src: Point; VAR dst: Point);
  1435.     {$IFC NOT GENERATINGCFM}
  1436.     INLINE $A87F;
  1437.     {$ENDC}
  1438. FUNCTION PtInRgn(pt: Point; rgn: RgnHandle): BOOLEAN;
  1439.     {$IFC NOT GENERATINGCFM}
  1440.     INLINE $A8E8;
  1441.     {$ENDC}
  1442. PROCEDURE StdLine(newPt: Point);
  1443.     {$IFC NOT GENERATINGCFM}
  1444.     INLINE $A890;
  1445.     {$ENDC}
  1446. PROCEDURE OpenCPort(port: CGrafPtr);
  1447.     {$IFC NOT GENERATINGCFM}
  1448.     INLINE $AA00;
  1449.     {$ENDC}
  1450. PROCEDURE InitCPort(port: CGrafPtr);
  1451.     {$IFC NOT GENERATINGCFM}
  1452.     INLINE $AA01;
  1453.     {$ENDC}
  1454. PROCEDURE CloseCPort(port: CGrafPtr);
  1455.     {$IFC NOT GENERATINGCFM}
  1456.     INLINE $AA02;
  1457.     {$ENDC}
  1458. FUNCTION NewPixMap: PixMapHandle;
  1459.     {$IFC NOT GENERATINGCFM}
  1460.     INLINE $AA03;
  1461.     {$ENDC}
  1462. PROCEDURE DisposePixMap(pm: PixMapHandle);
  1463.     {$IFC NOT GENERATINGCFM}
  1464.     INLINE $AA04;
  1465.     {$ENDC}
  1466. PROCEDURE CopyPixMap(srcPM: PixMapHandle; dstPM: PixMapHandle);
  1467.     {$IFC NOT GENERATINGCFM}
  1468.     INLINE $AA05;
  1469.     {$ENDC}
  1470. FUNCTION NewPixPat: PixPatHandle;
  1471.     {$IFC NOT GENERATINGCFM}
  1472.     INLINE $AA07;
  1473.     {$ENDC}
  1474. PROCEDURE DisposePixPat(pp: PixPatHandle);
  1475.     {$IFC NOT GENERATINGCFM}
  1476.     INLINE $AA08;
  1477.     {$ENDC}
  1478. PROCEDURE CopyPixPat(srcPP: PixPatHandle; dstPP: PixPatHandle);
  1479.     {$IFC NOT GENERATINGCFM}
  1480.     INLINE $AA09;
  1481.     {$ENDC}
  1482. PROCEDURE PenPixPat(pp: PixPatHandle);
  1483.     {$IFC NOT GENERATINGCFM}
  1484.     INLINE $AA0A;
  1485.     {$ENDC}
  1486. PROCEDURE BackPixPat(pp: PixPatHandle);
  1487.     {$IFC NOT GENERATINGCFM}
  1488.     INLINE $AA0B;
  1489.     {$ENDC}
  1490. FUNCTION GetPixPat(patID: INTEGER): PixPatHandle;
  1491.     {$IFC NOT GENERATINGCFM}
  1492.     INLINE $AA0C;
  1493.     {$ENDC}
  1494. PROCEDURE MakeRGBPat(pp: PixPatHandle; {CONST}VAR myColor: RGBColor);
  1495.     {$IFC NOT GENERATINGCFM}
  1496.     INLINE $AA0D;
  1497.     {$ENDC}
  1498. PROCEDURE FillCRect({CONST}VAR r: Rect; pp: PixPatHandle);
  1499.     {$IFC NOT GENERATINGCFM}
  1500.     INLINE $AA0E;
  1501.     {$ENDC}
  1502. PROCEDURE FillCOval({CONST}VAR r: Rect; pp: PixPatHandle);
  1503.     {$IFC NOT GENERATINGCFM}
  1504.     INLINE $AA0F;
  1505.     {$ENDC}
  1506. PROCEDURE FillCRoundRect({CONST}VAR r: Rect; ovalWidth: INTEGER; ovalHeight: INTEGER; pp: PixPatHandle);
  1507.     {$IFC NOT GENERATINGCFM}
  1508.     INLINE $AA10;
  1509.     {$ENDC}
  1510. PROCEDURE FillCArc({CONST}VAR r: Rect; startAngle: INTEGER; arcAngle: INTEGER; pp: PixPatHandle);
  1511.     {$IFC NOT GENERATINGCFM}
  1512.     INLINE $AA11;
  1513.     {$ENDC}
  1514. PROCEDURE FillCRgn(rgn: RgnHandle; pp: PixPatHandle);
  1515.     {$IFC NOT GENERATINGCFM}
  1516.     INLINE $AA12;
  1517.     {$ENDC}
  1518. PROCEDURE FillCPoly(poly: PolyHandle; pp: PixPatHandle);
  1519.     {$IFC NOT GENERATINGCFM}
  1520.     INLINE $AA13;
  1521.     {$ENDC}
  1522. PROCEDURE RGBForeColor({CONST}VAR color: RGBColor);
  1523.     {$IFC NOT GENERATINGCFM}
  1524.     INLINE $AA14;
  1525.     {$ENDC}
  1526. PROCEDURE RGBBackColor({CONST}VAR color: RGBColor);
  1527.     {$IFC NOT GENERATINGCFM}
  1528.     INLINE $AA15;
  1529.     {$ENDC}
  1530. PROCEDURE SetCPixel(h: INTEGER; v: INTEGER; {CONST}VAR cPix: RGBColor);
  1531.     {$IFC NOT GENERATINGCFM}
  1532.     INLINE $AA16;
  1533.     {$ENDC}
  1534. PROCEDURE SetPortPix(pm: PixMapHandle);
  1535.     {$IFC NOT GENERATINGCFM}
  1536.     INLINE $AA06;
  1537.     {$ENDC}
  1538. PROCEDURE GetCPixel(h: INTEGER; v: INTEGER; VAR cPix: RGBColor);
  1539.     {$IFC NOT GENERATINGCFM}
  1540.     INLINE $AA17;
  1541.     {$ENDC}
  1542. PROCEDURE GetForeColor(VAR color: RGBColor);
  1543.     {$IFC NOT GENERATINGCFM}
  1544.     INLINE $AA19;
  1545.     {$ENDC}
  1546. PROCEDURE GetBackColor(VAR color: RGBColor);
  1547.     {$IFC NOT GENERATINGCFM}
  1548.     INLINE $AA1A;
  1549.     {$ENDC}
  1550. PROCEDURE SeedCFill({CONST}VAR srcBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; seedH: INTEGER; seedV: INTEGER; matchProc: ColorSearchUPP; matchData: LONGINT);
  1551.     {$IFC NOT GENERATINGCFM}
  1552.     INLINE $AA50;
  1553.     {$ENDC}
  1554. PROCEDURE CalcCMask({CONST}VAR srcBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR dstRect: Rect; {CONST}VAR seedRGB: RGBColor; matchProc: ColorSearchUPP; matchData: LONGINT);
  1555.     {$IFC NOT GENERATINGCFM}
  1556.     INLINE $AA4F;
  1557.     {$ENDC}
  1558. FUNCTION OpenCPicture({CONST}VAR newHeader: OpenCPicParams): PicHandle;
  1559.     {$IFC NOT GENERATINGCFM}
  1560.     INLINE $AA20;
  1561.     {$ENDC}
  1562. PROCEDURE OpColor({CONST}VAR color: RGBColor);
  1563.     {$IFC NOT GENERATINGCFM}
  1564.     INLINE $AA21;
  1565.     {$ENDC}
  1566. PROCEDURE HiliteColor({CONST}VAR color: RGBColor);
  1567.     {$IFC NOT GENERATINGCFM}
  1568.     INLINE $AA22;
  1569.     {$ENDC}
  1570. PROCEDURE DisposeCTable(cTable: CTabHandle);
  1571.     {$IFC NOT GENERATINGCFM}
  1572.     INLINE $AA24;
  1573.     {$ENDC}
  1574. FUNCTION GetCTable(ctID: INTEGER): CTabHandle;
  1575.     {$IFC NOT GENERATINGCFM}
  1576.     INLINE $AA18;
  1577.     {$ENDC}
  1578. FUNCTION GetCCursor(crsrID: INTEGER): CCrsrHandle;
  1579.     {$IFC NOT GENERATINGCFM}
  1580.     INLINE $AA1B;
  1581.     {$ENDC}
  1582. PROCEDURE SetCCursor(cCrsr: CCrsrHandle);
  1583.     {$IFC NOT GENERATINGCFM}
  1584.     INLINE $AA1C;
  1585.     {$ENDC}
  1586. PROCEDURE AllocCursor;
  1587.     {$IFC NOT GENERATINGCFM}
  1588.     INLINE $AA1D;
  1589.     {$ENDC}
  1590. PROCEDURE DisposeCCursor(cCrsr: CCrsrHandle);
  1591.     {$IFC NOT GENERATINGCFM}
  1592.     INLINE $AA26;
  1593.     {$ENDC}
  1594. {$IFC OLDROUTINELOCATIONS }
  1595. FUNCTION GetCIcon(iconID: INTEGER): CIconHandle;
  1596.     {$IFC NOT GENERATINGCFM}
  1597.     INLINE $AA1E;
  1598.     {$ENDC}
  1599. PROCEDURE PlotCIcon({CONST}VAR theRect: Rect; theIcon: CIconHandle);
  1600.     {$IFC NOT GENERATINGCFM}
  1601.     INLINE $AA1F;
  1602.     {$ENDC}
  1603. PROCEDURE DisposeCIcon(theIcon: CIconHandle);
  1604.     {$IFC NOT GENERATINGCFM}
  1605.     INLINE $AA25;
  1606.     {$ENDC}
  1607. {$ENDC}
  1608. PROCEDURE SetStdCProcs(VAR procs: CQDProcs);
  1609.     {$IFC NOT GENERATINGCFM}
  1610.     INLINE $AA4E;
  1611.     {$ENDC}
  1612. FUNCTION GetMaxDevice({CONST}VAR globalRect: Rect): GDHandle;
  1613.     {$IFC NOT GENERATINGCFM}
  1614.     INLINE $AA27;
  1615.     {$ENDC}
  1616. FUNCTION GetCTSeed: LONGINT;
  1617.     {$IFC NOT GENERATINGCFM}
  1618.     INLINE $AA28;
  1619.     {$ENDC}
  1620. FUNCTION GetDeviceList: GDHandle;
  1621.     {$IFC NOT GENERATINGCFM}
  1622.     INLINE $AA29;
  1623.     {$ENDC}
  1624. FUNCTION GetMainDevice: GDHandle;
  1625.     {$IFC NOT GENERATINGCFM}
  1626.     INLINE $AA2A;
  1627.     {$ENDC}
  1628. FUNCTION GetNextDevice(curDevice: GDHandle): GDHandle;
  1629.     {$IFC NOT GENERATINGCFM}
  1630.     INLINE $AA2B;
  1631.     {$ENDC}
  1632. FUNCTION TestDeviceAttribute(gdh: GDHandle; attribute: INTEGER): BOOLEAN;
  1633.     {$IFC NOT GENERATINGCFM}
  1634.     INLINE $AA2C;
  1635.     {$ENDC}
  1636. PROCEDURE SetDeviceAttribute(gdh: GDHandle; attribute: INTEGER; value: BOOLEAN);
  1637.     {$IFC NOT GENERATINGCFM}
  1638.     INLINE $AA2D;
  1639.     {$ENDC}
  1640. PROCEDURE InitGDevice(qdRefNum: INTEGER; mode: LONGINT; gdh: GDHandle);
  1641.     {$IFC NOT GENERATINGCFM}
  1642.     INLINE $AA2E;
  1643.     {$ENDC}
  1644. FUNCTION NewGDevice(refNum: INTEGER; mode: LONGINT): GDHandle;
  1645.     {$IFC NOT GENERATINGCFM}
  1646.     INLINE $AA2F;
  1647.     {$ENDC}
  1648. PROCEDURE DisposeGDevice(gdh: GDHandle);
  1649.     {$IFC NOT GENERATINGCFM}
  1650.     INLINE $AA30;
  1651.     {$ENDC}
  1652. PROCEDURE SetGDevice(gd: GDHandle);
  1653.     {$IFC NOT GENERATINGCFM}
  1654.     INLINE $AA31;
  1655.     {$ENDC}
  1656. FUNCTION GetGDevice: GDHandle;
  1657.     {$IFC NOT GENERATINGCFM}
  1658.     INLINE $AA32;
  1659.     {$ENDC}
  1660. FUNCTION Color2Index({CONST}VAR myColor: RGBColor): LONGINT;
  1661.     {$IFC NOT GENERATINGCFM}
  1662.     INLINE $AA33;
  1663.     {$ENDC}
  1664. PROCEDURE Index2Color(index: LONGINT; VAR aColor: RGBColor);
  1665.     {$IFC NOT GENERATINGCFM}
  1666.     INLINE $AA34;
  1667.     {$ENDC}
  1668. PROCEDURE InvertColor(VAR myColor: RGBColor);
  1669.     {$IFC NOT GENERATINGCFM}
  1670.     INLINE $AA35;
  1671.     {$ENDC}
  1672. FUNCTION RealColor({CONST}VAR color: RGBColor): BOOLEAN;
  1673.     {$IFC NOT GENERATINGCFM}
  1674.     INLINE $AA36;
  1675.     {$ENDC}
  1676. PROCEDURE GetSubTable(myColors: CTabHandle; iTabRes: INTEGER; targetTbl: CTabHandle);
  1677.     {$IFC NOT GENERATINGCFM}
  1678.     INLINE $AA37;
  1679.     {$ENDC}
  1680. PROCEDURE MakeITable(cTabH: CTabHandle; iTabH: ITabHandle; res: INTEGER);
  1681.     {$IFC NOT GENERATINGCFM}
  1682.     INLINE $AA39;
  1683.     {$ENDC}
  1684. PROCEDURE AddSearch(searchProc: ColorSearchUPP);
  1685.     {$IFC NOT GENERATINGCFM}
  1686.     INLINE $AA3A;
  1687.     {$ENDC}
  1688. PROCEDURE AddComp(compProc: ColorComplementUPP);
  1689.     {$IFC NOT GENERATINGCFM}
  1690.     INLINE $AA3B;
  1691.     {$ENDC}
  1692. PROCEDURE DelSearch(searchProc: ColorSearchUPP);
  1693.     {$IFC NOT GENERATINGCFM}
  1694.     INLINE $AA4C;
  1695.     {$ENDC}
  1696. PROCEDURE DelComp(compProc: ColorComplementUPP);
  1697.     {$IFC NOT GENERATINGCFM}
  1698.     INLINE $AA4D;
  1699.     {$ENDC}
  1700. PROCEDURE SetClientID(id: INTEGER);
  1701.     {$IFC NOT GENERATINGCFM}
  1702.     INLINE $AA3C;
  1703.     {$ENDC}
  1704. PROCEDURE ProtectEntry(index: INTEGER; protect: BOOLEAN);
  1705.     {$IFC NOT GENERATINGCFM}
  1706.     INLINE $AA3D;
  1707.     {$ENDC}
  1708. PROCEDURE ReserveEntry(index: INTEGER; reserve: BOOLEAN);
  1709.     {$IFC NOT GENERATINGCFM}
  1710.     INLINE $AA3E;
  1711.     {$ENDC}
  1712. PROCEDURE SetEntries(start: INTEGER; count: INTEGER; VAR aTable: CSpecArray);
  1713.     {$IFC NOT GENERATINGCFM}
  1714.     INLINE $AA3F;
  1715.     {$ENDC}
  1716. PROCEDURE SaveEntries(srcTable: CTabHandle; resultTable: CTabHandle; VAR selection: ReqListRec);
  1717.     {$IFC NOT GENERATINGCFM}
  1718.     INLINE $AA49;
  1719.     {$ENDC}
  1720. PROCEDURE RestoreEntries(srcTable: CTabHandle; dstTable: CTabHandle; VAR selection: ReqListRec);
  1721.     {$IFC NOT GENERATINGCFM}
  1722.     INLINE $AA4A;
  1723.     {$ENDC}
  1724. FUNCTION QDError: INTEGER;
  1725.     {$IFC NOT GENERATINGCFM}
  1726.     INLINE $AA40;
  1727.     {$ENDC}
  1728. PROCEDURE CopyDeepMask({CONST}VAR srcBits: BitMap; {CONST}VAR maskBits: BitMap; {CONST}VAR dstBits: BitMap; {CONST}VAR srcRect: Rect; {CONST}VAR maskRect: Rect; {CONST}VAR dstRect: Rect; mode: INTEGER; maskRgn: RgnHandle);
  1729.     {$IFC NOT GENERATINGCFM}
  1730.     INLINE $AA51;
  1731.     {$ENDC}
  1732. PROCEDURE DeviceLoop(drawingRgn: RgnHandle; drawingProc: DeviceLoopDrawingUPP; userData: LONGINT; flags: DeviceLoopFlags);
  1733.     {$IFC NOT GENERATINGCFM}
  1734.     INLINE $ABCA;
  1735.     {$ENDC}
  1736. {$IFC FOR_SYSTEM8_COOPERATIVE }
  1737. PROCEDURE NativeDeviceLoop(drawingRgn: RgnHandle; drawingProc: NativeDeviceLoopDrawingProcPtr; userData: LONGINT; flags: DeviceLoopFlags);
  1738. {$ENDC}
  1739. FUNCTION GetMaskTable: Ptr;
  1740.     {$IFC NOT GENERATINGCFM}
  1741.     INLINE $A836, $2E88;
  1742.     {$ENDC}
  1743. FUNCTION GetPattern(patternID: INTEGER): PatHandle;
  1744.     {$IFC NOT GENERATINGCFM}
  1745.     INLINE $A9B8;
  1746.     {$ENDC}
  1747. FUNCTION GetCursor(cursorID: INTEGER): CursHandle;
  1748.     {$IFC NOT GENERATINGCFM}
  1749.     INLINE $A9B9;
  1750.     {$ENDC}
  1751. FUNCTION GetPicture(pictureID: INTEGER): PicHandle;
  1752.     {$IFC NOT GENERATINGCFM}
  1753.     INLINE $A9BC;
  1754.     {$ENDC}
  1755. FUNCTION DeltaPoint(ptA: Point; ptB: Point): LONGINT;
  1756.     {$IFC NOT GENERATINGCFM}
  1757.     INLINE $A94F;
  1758.     {$ENDC}
  1759. PROCEDURE ShieldCursor({CONST}VAR shieldRect: Rect; offsetPt: Point);
  1760.     {$IFC NOT GENERATINGCFM}
  1761.     INLINE $A855;
  1762.     {$ENDC}
  1763. PROCEDURE ScreenRes(VAR scrnHRes: INTEGER; VAR scrnVRes: INTEGER);
  1764.     {$IFC NOT GENERATINGCFM}
  1765.     INLINE $225F, $32B8, $0102, $225F, $32B8, $0104;
  1766.     {$ENDC}
  1767. PROCEDURE GetIndPattern(VAR thePat: Pattern; patternListID: INTEGER; index: INTEGER);
  1768. {$IFC OLDROUTINENAMES }
  1769. PROCEDURE DisposPixMap(pm: PixMapHandle);
  1770.     {$IFC NOT GENERATINGCFM}
  1771.     INLINE $AA04;
  1772.     {$ENDC}
  1773. PROCEDURE DisposPixPat(pp: PixPatHandle);
  1774.     {$IFC NOT GENERATINGCFM}
  1775.     INLINE $AA08;
  1776.     {$ENDC}
  1777. PROCEDURE DisposCTable(cTable: CTabHandle);
  1778.     {$IFC NOT GENERATINGCFM}
  1779.     INLINE $AA24;
  1780.     {$ENDC}
  1781. PROCEDURE DisposCCursor(cCrsr: CCrsrHandle);
  1782.     {$IFC NOT GENERATINGCFM}
  1783.     INLINE $AA26;
  1784.     {$ENDC}
  1785. {$IFC OLDROUTINELOCATIONS }
  1786. PROCEDURE DisposCIcon(theIcon: CIconHandle);
  1787.     {$IFC NOT GENERATINGCFM}
  1788.     INLINE $AA25;
  1789.     {$ENDC}
  1790. {$ENDC}
  1791. PROCEDURE DisposGDevice(gdh: GDHandle);
  1792.     {$IFC NOT GENERATINGCFM}
  1793.     INLINE $AA30;
  1794.     {$ENDC}
  1795. {$IFC OLDROUTINELOCATIONS }
  1796. {$ENDC}
  1797. {$ENDC}
  1798. {
  1799.     From ToolUtils.i
  1800. }
  1801. PROCEDURE PackBits(VAR srcPtr: Ptr; VAR dstPtr: Ptr; srcBytes: INTEGER);
  1802.     {$IFC NOT GENERATINGCFM}
  1803.     INLINE $A8CF;
  1804.     {$ENDC}
  1805. PROCEDURE UnpackBits(VAR srcPtr: Ptr; VAR dstPtr: Ptr; dstBytes: INTEGER);
  1806.     {$IFC NOT GENERATINGCFM}
  1807.     INLINE $A8D0;
  1808.     {$ENDC}
  1809. {$ENDC}
  1810. {$IFC FOR_SYSTEM7_AND_SYSTEM8_PREEMPTIVE }
  1811. {
  1812.     Also from ToolUtils.i
  1813. }
  1814. FUNCTION SlopeFromAngle(angle: INTEGER): Fixed;
  1815.     {$IFC NOT GENERATINGCFM}
  1816.     INLINE $A8BC;
  1817.     {$ENDC}
  1818. FUNCTION AngleFromSlope(slope: Fixed): INTEGER;
  1819.     {$IFC NOT GENERATINGCFM}
  1820.     INLINE $A8C4;
  1821.     {$ENDC}
  1822. {$ENDC}
  1823. {$ALIGN RESET}
  1824. {$POP}
  1825.  
  1826. {$SETC UsingIncludes := QuickdrawIncludes}
  1827.  
  1828. {$ENDC} {__QUICKDRAW__}
  1829.  
  1830. {$IFC NOT UsingIncludes}
  1831.  END.
  1832. {$ENDC}
  1833.